package com.it.code.util;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import lombok.extern.slf4j.Slf4j;
import org.springframework.lang.Nullable;

import java.io.IOException;
import java.util.List;
import java.util.Map;

/**
 * @ClassName: JsonUtils
 * @description: json格式化工具类
 * @author: 李东
 * @Date: 2020-7-6 11:25
 */
@Slf4j
public class JsonUtils {

    public static final ObjectMapper mapper = new ObjectMapper();

    /**
     * @description: 对象转json字符串
     * @Param: [obj]
     * @return: java.lang.String
     * @author: 李东
     * @time: 2020-7-6 11:27
     **/
    @Nullable
    public static String serialize(Object obj) {
        if (obj == null) {
            return null;
        }
        if (obj.getClass() == String.class) {
            return (String) obj;
        }
        try {
            return mapper.writeValueAsString(obj);
        } catch (JsonProcessingException e) {
            log.error("对象转json字符串出错：{}", e);
            throw new RuntimeException("对象转json字符串出错", e);
        }
    }

    /**
     * @description: json字符串转对象
     * @Param: [json, tClass]
     * @return: T
     * @author: 李东
     * @time: 2020-7-6 11:30
     **/
    @Nullable
    public static <T> T parse(String json, Class<T> tClass) {
        try {
            return mapper.readValue(json, tClass);
        } catch (IOException e) {
            log.error("json字符串转对象出错：{}", e);
            throw new RuntimeException("json字符串转对象出错", e);
        }
    }

    /**
     * @description: json字符串转对象的List集合
     * @Param: [json, eClass]
     * @return: java.util.List<E>
     * @author: 李东
     * @time: 2020-7-6 11:31
     **/
    @Nullable
    public static <E> List<E> parseList(String json, Class<E> eClass) {
        try {
            return mapper.readValue(json,
                    mapper.getTypeFactory().constructCollectionType(List.class, eClass));
        } catch (IOException e) {
            log.error("json字符串转对象的List集合出错：{}", e);
            throw new RuntimeException("json字符串转对象的List集合出错", e);
        }
    }

    /**
     * @description: json字符串对象对应的map集合
     * @Param: [json, kClass, vClass]
     * @return: java.util.Map<K,V>
     * @author: 李东
     * @time: 2020-7-6 11:32
     **/
    @Nullable
    public static <K, V> Map<K, V> parseMap(String json, Class<K> kClass, Class<V> vClass) {
        try {
            return mapper.readValue(json,
                    mapper.getTypeFactory().constructMapType(Map.class, kClass, vClass));
        } catch (IOException e) {
            log.error("json字符串对象对应的map集合出错：{}", e);
            throw new RuntimeException("json字符串对象对应的map集合出错", e);
        }
    }


    /**
     * 根据类型，将json字符串转对应类型的对象或集合
     * 
     * @param json
     * @param type
     * @param <T>
     * @return
     */
    @Nullable
    public static <T> T parseByType(String json, TypeReference<T> type) {
        try {
            return mapper.readValue(json, type);
        } catch (IOException e) {
            log.error("根据对象类型，将json字符串转对象出错：{}", e);
            throw new RuntimeException("根据对象类型，将json字符串转对象出错", e);
        }
    }


    /**
     * @description: 具体使用示例 main方法测试
     * @Param: [args]
     * @return: void
     * @author: 李东
     * @time: 2020-7-6 11:46
     **/
    // public static void main(String[] args) {
    //
    // String json = "[{'name':'hehe','age':22}]";
    //
    //
    //
    // // 1.对象转json
    // ObjectRestResponse res = new ObjectRestResponseTable();
    // res.setResultCode(200);
    // String jsonObj = com.gr.claimmidplatform.utils.datautil.JsonUtils.serialize(res);
    // System.out.println("对象转json:" + jsonObj);
    //
    // // 2.List集合转json
    // List<String> list = new ArrayList<>();
    // list.add("123");
    // list.add("234");
    // list.add("345");
    // String jsonList = com.gr.claimmidplatform.utils.datautil.JsonUtils.serialize(list);
    // System.out.println("集合转json:" + jsonList);
    //
    // // 3.map集合转json
    // Map<String, String> map = new HashMap<>();
    // map.put("key1", "123");
    // map.put("key2", "234");
    // map.put("key3", "345");
    // String jsonMap = com.gr.claimmidplatform.utils.datautil.JsonUtils.serialize(map);
    // System.out.println("map集合转json:" + jsonMap);
    //
    // // 4.json字符串转对象
    // ObjectRestResponse parse = com.gr.claimmidplatform.utils.datautil.JsonUtils.parse(jsonObj,
    // ObjectRestResponseTable.class);
    // System.out.println("json字符串转对象:" + parse);
    //
    // // 5.json字符串转List集合
    // List<String> listStr = com.gr.claimmidplatform.utils.datautil.JsonUtils.parseList(jsonList,
    // String.class);
    // System.out.println("json字符串转List集合" + list);
    //
    // // 6.json字符串转Map集合
    // Map<String, String> mapStr =
    // com.gr.claimmidplatform.utils.datautil.JsonUtils.parseMap(jsonMap, String.class,
    // String.class);
    // System.out.println("json字符串转Map集合:" + mapStr);
    //
    // // 7.根据类型，将json字符串转对应类型的对象或集合
    // List<String> listType =
    // com.gr.claimmidplatform.utils.datautil.JsonUtils.parseByType(jsonList, new
    // TypeReference<List<String>>() {});
    // System.out.println("根据类型，将json字符串转对应类型的对象或集合list:" + listType);
    // Map<String, String> mapType =
    // com.gr.claimmidplatform.utils.datautil.JsonUtils.parseByType(jsonMap, new
    // TypeReference<Map<String, String>>() {});
    // System.out.println("根据类型，将json字符串转对应类型的对象或集合map:" + mapType);
    //
    //
    //
    // }

}
